home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / FSM.h < prev    next >
C/C++ Source or Header  |  1996-05-01  |  36KB  |  985 lines

  1. /*
  2.      File:        FSM.h
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. */
  18. #ifndef __FSM__
  19. #define __FSM__
  20.  
  21. #ifndef __FILES__
  22. #include <Files.h>
  23. #endif
  24.  
  25. #ifdef __cplusplus
  26. extern "C" {
  27. #endif
  28.  
  29. #if PRAGMA_IMPORT_SUPPORTED
  30. #pragma import on
  31. #endif
  32.  
  33. #if PRAGMA_ALIGN_SUPPORTED
  34. #pragma options align=mac68k
  35. #endif
  36.  
  37. #if FOR_SYSTEM7_ONLY
  38. #if OLDROUTINELOCATIONS
  39. /*
  40.  * gestaltFSMVersion should be in Gestalt.h
  41.  *
  42.  * VCBPtr, new volume mount flags, and VolumeMountInfoHeader
  43.  * should be in Files.h
  44. */
  45. /*    The new volume mount flags */
  46.  
  47. enum {
  48.     volMountInteractBit            = 15,                            /* Input to VolumeMount: If set, it's OK for the file system */
  49.     volMountInteractMask        = 0x8000,                        /* to perform user interaction to mount the volume */
  50.     volMountChangedBit            = 14,                            /* Output from VoumeMount: If set, the volume was mounted, but */
  51.     volMountChangedMask            = 0x4000,                        /* the volume mounting information record needs to be updated. */
  52.     volMountFSReservedMask        = 0x00FF,                        /* bits 0-7 are defined by each file system for its own use */
  53.     volMountSysReservedMask        = 0xFF00                        /* bits 8-15 are reserved for Apple system use */
  54. };
  55.  
  56. /*
  57.  * additional volume mount info record
  58. */
  59. struct VolumeMountInfoHeader {
  60.     short                             length;                        /* length of location data (including self) */
  61.     VolumeType                         media;                        /* type of media (must be registered with Apple) */
  62.     short                             flags;                        /* volume mount flags. Variable length data follows */
  63. };
  64. typedef struct VolumeMountInfoHeader VolumeMountInfoHeader;
  65.  
  66. typedef VolumeMountInfoHeader *VolumeMountInfoHeaderPtr;
  67.  
  68. enum {
  69.     gestaltFSMVersion            = 'fsm '
  70. };
  71.  
  72. typedef VCB *VCBPtr;
  73. #endif
  74. /*
  75.  * Miscellaneous file system values not in Files.h
  76. */
  77.  
  78. enum {
  79.     fsUsrCNID                    = 16,                            /* First assignable directory or file number */
  80.                                                                 /*    File system trap word attribute bits */
  81.     kHFSBit                        = 9,                            /* HFS call: bit 9 */
  82.     kHFSMask                    = 0x0200,
  83.     kAsyncBit                    = 10,                            /* Asynchronous call: bit 10 */
  84.     kAsyncMask                    = 0x0400
  85. };
  86.  
  87. /*
  88.  * HFSCIProc selectCode values
  89.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  90.  * may be set in these selectCode values.
  91. */
  92.  
  93. enum {
  94.     kFSMOpen                    = 0xA000,
  95.     kFSMClose                    = 0xA001,
  96.     kFSMRead                    = 0xA002,
  97.     kFSMWrite                    = 0xA003,
  98.     kFSMGetVolInfo                = 0xA007,
  99.     kFSMCreate                    = 0xA008,
  100.     kFSMDelete                    = 0xA009,
  101.     kFSMOpenRF                    = 0xA00A,
  102.     kFSMRename                    = 0xA00B,
  103.     kFSMGetFileInfo                = 0xA00C,
  104.     kFSMSetFileInfo                = 0xA00D,
  105.     kFSMUnmountVol                = 0xA00E,
  106.     kFSMMountVol                = 0xA00F,
  107.     kFSMAllocate                = 0xA010,
  108.     kFSMGetEOF                    = 0xA011,
  109.     kFSMSetEOF                    = 0xA012,
  110.     kFSMFlushVol                = 0xA013,
  111.     kFSMGetVol                    = 0xA014,
  112.     kFSMSetVol                    = 0xA015,
  113.     kFSMEject                    = 0xA017,
  114.     kFSMGetFPos                    = 0xA018,
  115.     kFSMOffline                    = 0xA035,
  116.     kFSMSetFilLock                = 0xA041,
  117.     kFSMRstFilLock                = 0xA042,
  118.     kFSMSetFilType                = 0xA043,
  119.     kFSMSetFPos                    = 0xA044,
  120.     kFSMFlushFile                = 0xA045,                        /*    The File System HFSDispatch selectCodes */
  121.     kFSMOpenWD                    = 0x0001,
  122.     kFSMCloseWD                    = 0x0002,
  123.     kFSMCatMove                    = 0x0005,
  124.     kFSMDirCreate                = 0x0006,
  125.     kFSMGetWDInfo                = 0x0007,
  126.     kFSMGetFCBInfo                = 0x0008,
  127.     kFSMGetCatInfo                = 0x0009,
  128.     kFSMSetCatInfo                = 0x000A,
  129.     kFSMSetVolInfo                = 0x000B,
  130.     kFSMLockRng                    = 0x0010,
  131.     kFSMUnlockRng                = 0x0011,
  132.     kFSMCreateFileIDRef            = 0x0014,
  133.     kFSMDeleteFileIDRef            = 0x0015,
  134.     kFSMResolveFileIDRef        = 0x0016,
  135.     kFSMExchangeFiles            = 0x0017,
  136.     kFSMCatSearch                = 0x0018,
  137.     kFSMOpenDF                    = 0x001A,
  138.     kFSMMakeFSSpec                = 0x001B,                        /*    The Desktop Manager HFSDispatch selectCodes */
  139.     kFSMDTGetPath                = 0x0020,
  140.     kFSMDTCloseDown                = 0x0021,
  141.     kFSMDTAddIcon                = 0x0022,
  142.     kFSMDTGetIcon                = 0x0023,
  143.     kFSMDTGetIconInfo            = 0x0024,
  144.     kFSMDTAddAPPL                = 0x0025,
  145.     kFSMDTRemoveAPPL            = 0x0026,
  146.     kFSMDTGetAPPL                = 0x0027,
  147.     kFSMDTSetComment            = 0x0028,
  148.     kFSMDTRemoveComment            = 0x0029,
  149.     kFSMDTGetComment            = 0x002A,
  150.     kFSMDTFlush                    = 0x002B,
  151.     kFSMDTReset                    = 0x002C,
  152.     kFSMDTGetInfo                = 0x002D,
  153.     kFSMDTOpenInform            = 0x002E,
  154.     kFSMDTDelete                = 0x002F,                        /*    The AppleShare HFSDispatch selectCodes */
  155.     kFSMGetVolParms                = 0x0030,
  156.     kFSMGetLogInInfo            = 0x0031,
  157.     kFSMGetDirAccess            = 0x0032,
  158.     kFSMSetDirAccess            = 0x0033,
  159.     kFSMMapID                    = 0x0034,
  160.     kFSMMapName                    = 0x0035,
  161.     kFSMCopyFile                = 0x0036,
  162.     kFSMMoveRename                = 0x0037,
  163.     kFSMOpenDeny                = 0x0038,
  164.     kFSMOpenRFDeny                = 0x0039,
  165.     kFSMGetXCatInfo                = 0x003A,
  166.     kFSMGetVolMountInfoSize        = 0x003F,
  167.     kFSMGetVolMountInfo            = 0x0040,
  168.     kFSMVolumeMount                = 0x0041,
  169.     kFSMShare                    = 0x0042,
  170.     kFSMUnShare                    = 0x0043,
  171.     kFSMGetUGEntry                = 0x0044,
  172.     kFSMGetForeignPrivs            = 0x0060,
  173.     kFSMSetForeignPrivs            = 0x0061
  174. };
  175.  
  176. /*
  177.  * UTDetermineVol status values
  178. */
  179.  
  180. enum {
  181.     dtmvError                    = 0,                            /* param error */
  182.     dtmvFullPathame                = 1,                            /* determined by full pathname */
  183.     dtmvVRefNum                    = 2,                            /* determined by volume refNum */
  184.     dtmvWDRefNum                = 3,                            /* determined by working directory refNum */
  185.     dtmvDriveNum                = 4,                            /* determined by drive number */
  186.     dtmvDefault                    = 5                                /* determined by default volume */
  187. };
  188.  
  189. /*
  190.  * UTGetBlock options
  191. */
  192.  
  193. enum {
  194.     gbDefault                    = 0,                            /* default value - read if not found */
  195.                                                                 /*    bits and masks */
  196.     gbReadBit                    = 0,                            /* read block from disk (forced read) */
  197.     gbReadMask                    = 0x0001,
  198.     gbExistBit                    = 1,                            /* get existing cache block */
  199.     gbExistMask                    = 0x0002,
  200.     gbNoReadBit                    = 2,                            /* don't read block from disk if not found in cache */
  201.     gbNoReadMask                = 0x0004,
  202.     gbReleaseBit                = 3,                            /* release block immediately after GetBlock */
  203.     gbReleaseMask                = 0x0008
  204. };
  205.  
  206. /*
  207.  * UTReleaseBlock options
  208. */
  209.  
  210. enum {
  211.     rbDefault                    = 0,                            /* default value - just mark the buffer not in-use */
  212.                                                                 /*    bits and masks */
  213.     rbWriteBit                    = 0,                            /* force write buffer to disk */
  214.     rbWriteMask                    = 0x0001,
  215.     rbTrashBit                    = 1,                            /* trash buffer contents after release */
  216.     rbTrashMask                    = 0x0002,
  217.     rbDirtyBit                    = 2,                            /* mark buffer dirty */
  218.     rbDirtyMask                    = 0x0004,
  219.     rbFreeBit                    = 3,                            /* free the buffer (save in the hash) */
  220.     rbFreeMask                    = 0x000A                        /* rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash */
  221. };
  222.  
  223. /*
  224.  * UTFlushCache options
  225. */
  226.  
  227. enum {
  228.     fcDefault                    = 0,                            /* default value - just flush any dirty buffers */
  229.                                                                 /*    bits and masks */
  230.     fcTrashBit                    = 1,                            /* trash buffers after flushing */
  231.     fcTrashMask                    = 0x0002,
  232.     fcFreeBit                    = 3,                            /* free buffers after flushing */
  233.     fcFreeMask                    = 0x0008                        /* fcFreeMask works as fcTrash on < System 7.0 RamCache */
  234. };
  235.  
  236. /*
  237.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  238. */
  239.  
  240. enum {
  241.     noCacheBit                    = 5,                            /* don't cache this please */
  242.     noCacheMask                    = 0x0020,
  243.     rdVerifyBit                    = 6,                            /* read verify */
  244.     rdVerifyMask                = 0x0040
  245. };
  246.  
  247. /*
  248.  * Cache routine internal error codes
  249. */
  250.  
  251. enum {
  252.     chNoBuf                        = 1,                            /* no free cache buffers (all in use) */
  253.     chInUse                        = 2,                            /* requested block in use */
  254.     chnotfound                    = 3,                            /* requested block not found */
  255.     chNotInUse                    = 4                                /* block being released was not in use */
  256. };
  257.  
  258. /*
  259.  * FCBRec.fcbFlags bits
  260. */
  261.  
  262. enum {
  263.     fcbWriteBit                    = 0,                            /* Data can be written to this file */
  264.     fcbWriteMask                = 0x01,
  265.     fcbResourceBit                = 1,                            /* This file is a resource fork */
  266.     fcbResourceMask                = 0x02,
  267.     fcbWriteLockedBit            = 2,                            /* File has a locked byte range */
  268.     fcbWriteLockedMask            = 0x04,
  269.     fcbSharedWriteBit            = 4,                            /* File is open for shared write access */
  270.     fcbSharedWriteMask            = 0x10,
  271.     fcbFileLockedBit            = 5,                            /* File is locked (write-protected) */
  272.     fcbFileLockedMask            = 0x20,
  273.     fcbOwnClumpBit                = 6,                            /* File has clump size specified in FCB */
  274.     fcbOwnClumpMask                = 0x40,
  275.     fcbModifiedBit                = 7,                            /* File has changed since it was last flushed */
  276.     fcbModifiedMask                = 0x80
  277. };
  278.  
  279. /*
  280.  * ExtFileProc options
  281. */
  282.  
  283. enum {
  284.     extendFileAllBit            = 0,                            /* allocate all requested bytes or none */
  285.     extendFileAllMask            = 0x0001,
  286.     extendFileContigBit            = 1,                            /* force contiguous allocation */
  287.     extendFileContigMask        = 0x0002
  288. };
  289.  
  290. /*
  291.  *    HFS Component Interface constants
  292. */
  293. /*
  294.  * compInterfMask bits specific to HFS component
  295. */
  296.  
  297. enum {
  298.     hfsCIDoesHFSBit                = 23,                            /* set if file system supports HFS calls */
  299.     hfsCIDoesHFSMask            = 0x00800000,
  300.     hfsCIDoesAppleShareBit        = 22,                            /* set if AppleShare calls supported */
  301.     hfsCIDoesAppleShareMask        = 0x00400000,
  302.     hfsCIDoesDeskTopBit            = 21,                            /* set if Desktop Database calls supported */
  303.     hfsCIDoesDeskTopMask        = 0x00200000,
  304.     hfsCIDoesDynamicLoadBit        = 20,                            /* set if dynamically loading code resource */
  305.     hfsCIDoesDynamicLoadMask    = 0x00100000,                    /*        supported */
  306.     hfsCIResourceLoadedBit        = 19,                            /* set if code resource already loaded */
  307.     hfsCIResourceLoadedMask        = 0x00080000,
  308.     hfsCIHasHLL2PProcBit        = 18,                            /* set if FFS' log2PhyProc and Extendfile proc */
  309.     hfsCIHasHLL2PProcMask        = 0x00040000                    /* is written in a high level language. (i.e., uses Pascal calling convention) */
  310. };
  311.  
  312. /*
  313.  *    Disk Initialization Component Interface constants
  314. */
  315. /*
  316.  * compInterfMask bits specific to Disk Initialization component
  317. */
  318.  
  319. enum {
  320.     diCIHasExtFormatParamsBit    = 18,                            /* set if file system needs extended format */
  321.     diCIHasExtFormatParamsMask    = 0x00040000,                    /*        parameters */
  322.     diCIHasMultiVolTypesBit        = 17,                            /* set if file system supports more than one */
  323.     diCIHasMultiVolTypesMask    = 0x00020000,                    /*        volume type */
  324.     diCIDoesSparingBit            = 16,                            /* set if file system supports disk sparing */
  325.     diCIDoesSparingMask            = 0x00010000,
  326.     diCILiveBit                    = 0,                            /* set if file system is candidate for current */
  327.     diCILiveMask                = 0x00000001                    /*        formatting operation (set by PACK2) */
  328. };
  329.  
  330. /*
  331.  * Disk Initialization Component Function selectors
  332. */
  333.  
  334. enum {
  335.     diCILoad                    = 1,                            /* Make initialization code memory resident */
  336.     diCIUnload                    = 2,                            /* Make initialization code purgeable */
  337.     diCIEvaluateSizeChoices        = 3,                            /* Evaluate size choices */
  338.     diCIExtendedZero            = 4,                            /* Write an empty volume directory */
  339.     diCIValidateVolName            = 5,                            /* Validate volume name */
  340.     diCIGetVolTypeInfo            = 6,                            /* get volume type info */
  341.     diCIGetFormatString            = 7,                            /* get dialog format string */
  342.     diCIGetExtFormatParams        = 8,                            /* get extended format parameters */
  343.     diCIGetDefectList            = 9                                /* return the defect list for the indicated disk - reserved for future use */
  344. };
  345.  
  346. /*
  347.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  348. */
  349.  
  350. enum {
  351.     diCIFmtListMax                = 8,                            /* maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries */
  352.                                                                 /*    bits in FormatListRec.formatFlags: */
  353.     diCIFmtFlagsValidBit        = 7,                            /* set if sec, side, tracks valid */
  354.     diCIFmtFlagsValidMask        = 0x80,
  355.     diCIFmtFlagsCurrentBit        = 6,                            /* set if current disk has this fmt */
  356.     diCIFmtFlagsCurrentMask        = 0x40,                            /*    bits in FormatListRec.sizeListFlags: */
  357.     diCISizeListOKBit            = 15,                            /* set if this disk size usable */
  358.     diCISizeListOKMask            = 0x8000
  359. };
  360.  
  361. /*
  362.  * DICIGetFormatStringRec.stringKind format strings
  363. */
  364.  
  365. enum {
  366.     diCIAlternateFormatStr        = 1,                            /* get alternate format  string (Balloon Help) */
  367.     diCISizePresentationStr        = 2                                /* get size presentation string (for dialog) */
  368. };
  369.  
  370. /*
  371.  * Error codes returned by Disk Sparing
  372. */
  373.  
  374. enum {
  375.     diCIUserCancelErr            = 1,                            /* user cancelled the disk init */
  376.     diCICriticalSectorBadErr    = 20,                            /* critical sectors are bad (hopeless)    */
  377.     diCISparingFailedErr        = 21,                            /* disk cannot be spared */
  378.     diCITooManyBadSectorsErr    = 22,                            /* too many bad sectors */
  379.     diCIUnknownVolTypeErr        = 23,                            /* the volume type passed in diCIExtendedZero paramBlock is not supported */
  380.     diCIVolSizeMismatchErr        = 24,                            /* specified volume size doesn't match with formatted disk size */
  381.     diCIUnknownDICallErr        = 25,                            /* bogus DI function call selector */
  382.     diCINoSparingErr            = 26,                            /* disk is bad but the target FS doesn't do disk sparing */
  383.     diCINoExtendInfoErr            = 27,                            /* missing file system specific extra parameter in diCIExtendedZero call */
  384.     diCINoMessageTextErr        = 28                            /* missing message text in DIReformat call */
  385. };
  386.  
  387. /*
  388.  *    File System Manager constants
  389. */
  390. /*
  391.  * Miscellaneous constants used by FSM
  392. */
  393.  
  394. enum {
  395.     fsdVersion1                    = 1,                            /* current version of FSD record */
  396.     fsmIgnoreFSID                = 0xFFFE,                        /* this FSID should be ignored by the driver */
  397.     fsmGenericFSID                = 0xFFFF                        /* unknown foreign file system ID */
  398. };
  399.  
  400. /*
  401.  * compInterfMask bits common to all FSM components
  402. */
  403.  
  404. enum {
  405.     fsmComponentEnableBit        = 31,                            /* set if FSM component interface is enabled */
  406.     fsmComponentEnableMask        = 0x80000000,
  407.     fsmComponentBusyBit            = 30,                            /* set if FSM component interface is busy */
  408.     fsmComponentBusyMask        = 0x40000000
  409. };
  410.  
  411. /*
  412.  * Selectors for GetFSInfo
  413. */
  414.  
  415. enum {
  416.     fsmGetFSInfoByIndex            = -1,                            /* get fs info by index */
  417.     fsmGetFSInfoByFSID            = 0,                            /* get fs info by FSID */
  418.     fsmGetFSInfoByRefNum        = 1                                /* get fs info by file/vol refnum */
  419. };
  420.  
  421. /*
  422.  * InformFSM messages
  423. */
  424.  
  425. enum {
  426.     fsmNopMessage                = 0,                            /* nop */
  427.     fsmDrvQElChangedMessage        = 1,                            /* DQE has changed */
  428.     fsmGetFSIconMessage            = 2                                /* Get FFS's disk icon */
  429. };
  430.  
  431. /*
  432.  * Messages passed to the fileSystemCommProc
  433. */
  434.  
  435. enum {
  436.     ffsNopMessage                = 0,                            /* nop, should always return noErr */
  437.     ffsGetIconMessage            = 1,                            /* return disk icon and mask */
  438.     ffsIDDiskMessage            = 2,                            /* identify the about-to-be-mounted volume */
  439.     ffsLoadMessage                = 3,                            /* load in the FFS */
  440.     ffsUnloadMessage            = 4,                            /* unload the FFS */
  441.     ffsIDVolMountMessage        = 5,                            /* identify a VolMountInfo record */
  442.     ffsInformMessage            = 6,                            /* FFS defined message */
  443.     ffsGetIconInfoMessage        = 7
  444. };
  445.  
  446. /*
  447.  * Error codes from FSM functions
  448. */
  449.  
  450. enum {
  451.     fsmFFSNotFoundErr            = -431,                            /* Foreign File system does not exist - new Pack2 could return this error too */
  452.     fsmBusyFFSErr                = -432,                            /* File system is busy, cannot be removed */
  453.     fsmBadFFSNameErr            = -433,                            /* Name length not 1 <= length <= 31 */
  454.     fsmBadFSDLenErr                = -434,                            /* FSD size incompatible with current FSM vers */
  455.     fsmDuplicateFSIDErr            = -435,                            /* FSID already exists on InstallFS */
  456.     fsmBadFSDVersionErr            = -436,                            /* FSM version incompatible with FSD */
  457.     fsmNoAlternateStackErr        = -437,                            /* no alternate stack for HFS CI */
  458.     fsmUnknownFSMMessageErr        = -438                            /* unknown message passed to FSM */
  459. };
  460.  
  461. /*
  462.  *    HFS Utility routine records
  463. */
  464. /*
  465.  * record used by UTGetPathComponentName
  466. */
  467. struct ParsePathRec {
  468.     StringPtr                         namePtr;                    /* pathname to parse */
  469.     short                             startOffset;                /* where to start parsing */
  470.     short                             componentLength;            /* the length of the pathname component parsed */
  471.     SignedByte                         moreName;                    /* non-zero if there are more components after this one */
  472.     SignedByte                         foundDelimiter;                /* non-zero if parsing stopped because a colon (:) delimiter was found */
  473. };
  474. typedef struct ParsePathRec ParsePathRec;
  475.  
  476. typedef ParsePathRec *ParsePathRecPtr;
  477. struct WDCBRec {
  478.     VCBPtr                             wdVCBPtr;                    /* Pointer to VCB of this working directory */
  479.     long                             wdDirID;                    /* Directory ID number of this working directory */
  480.     long                             wdCatHint;                    /* Hint for finding this working directory */
  481.     long                             wdProcID;                    /* Process that created this working directory */
  482. };
  483. typedef struct WDCBRec WDCBRec;
  484.  
  485. typedef WDCBRec *WDCBRecPtr;
  486. struct FCBRec {
  487.     unsigned long                     fcbFlNm;                    /* FCB file number. Non-zero marks FCB used */
  488.     SignedByte                         fcbFlags;                    /* FCB flags */
  489.     SignedByte                         fcbTypByt;                    /* File type byte */
  490.     unsigned short                     fcbSBlk;                    /* File start block (in alloc size blks) */
  491.     unsigned long                     fcbEOF;                        /* Logical length or EOF in bytes */
  492.     unsigned long                     fcbPLen;                    /* Physical file length in bytes */
  493.     unsigned long                     fcbCrPs;                    /* Current position within file */
  494.     VCBPtr                             fcbVPtr;                    /* Pointer to the corresponding VCB */
  495.     Ptr                             fcbBfAdr;                    /* File's buffer address */
  496.     unsigned short                     fcbFlPos;                    /* Directory block this file is in */
  497.                                                                 /* FCB Extensions for HFS */
  498.     unsigned long                     fcbClmpSize;                /* Number of bytes per clump */
  499.     Ptr                             fcbBTCBPtr;                    /* Pointer to B*-Tree control block for file */
  500.     unsigned long                     fcbExtRec[3];                /* First 3 file extents */
  501.     OSType                             fcbFType;                    /* File's 4 Finder Type bytes */
  502.     unsigned long                     fcbCatPos;                    /* Catalog hint for use on Close */
  503.     unsigned long                     fcbDirID;                    /* Parent Directory ID */
  504.     Str31                             fcbCName;                    /* CName of open file */
  505. };
  506. typedef struct FCBRec FCBRec;
  507.  
  508. typedef FCBRec *FCBRecPtr;
  509. /*
  510.  *    HFS Component Interface records
  511. */
  512. typedef pascal OSErr (*Lg2PhysProcPtr)(void *fsdGlobalPtr, VCBPtr volCtrlBlockPtr, FCBRecPtr fileCtrlBlockPtr, short fileRefNum, unsigned long filePosition, unsigned long reqCount, unsigned long *volOffset, unsigned long *contiguousBytes);
  513.  
  514. #if GENERATINGCFM
  515. typedef UniversalProcPtr Lg2PhysUPP;
  516. #else
  517. typedef Lg2PhysProcPtr Lg2PhysUPP;
  518. #endif
  519.  
  520. enum {
  521.     uppLg2PhysProcInfo = kPascalStackBased
  522.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  523.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *)))
  524.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(VCBPtr)))
  525.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(FCBRecPtr)))
  526.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(short)))
  527.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(unsigned long)))
  528.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(unsigned long)))
  529.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(unsigned long *)))
  530.          | STACK_ROUTINE_PARAMETER(8, SIZE_CODE(sizeof(unsigned long *)))
  531. };
  532.  
  533. #if GENERATINGCFM
  534. #define NewLg2PhysProc(userRoutine)        \
  535.         (Lg2PhysUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppLg2PhysProcInfo, GetCurrentArchitecture())
  536. #else
  537. #define NewLg2PhysProc(userRoutine)        \
  538.         ((Lg2PhysUPP) (userRoutine))
  539. #endif
  540.  
  541. #if GENERATINGCFM
  542. #define CallLg2PhysProc(userRoutine, fsdGlobalPtr, volCtrlBlockPtr, fileCtrlBlockPtr, fileRefNum, filePosition, reqCount, volOffset, contiguousBytes)        \
  543.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppLg2PhysProcInfo, (fsdGlobalPtr), (volCtrlBlockPtr), (fileCtrlBlockPtr), (fileRefNum), (filePosition), (reqCount), (volOffset), (contiguousBytes))
  544. #else
  545. #define CallLg2PhysProc(userRoutine, fsdGlobalPtr, volCtrlBlockPtr, fileCtrlBlockPtr, fileRefNum, filePosition, reqCount, volOffset, contiguousBytes)        \
  546.         (*(userRoutine))((fsdGlobalPtr), (volCtrlBlockPtr), (fileCtrlBlockPtr), (fileRefNum), (filePosition), (reqCount), (volOffset), (contiguousBytes))
  547. #endif
  548. typedef pascal OSErr (*HFSCIProcPtr)(VCBPtr theVCB, short selectCode, void *paramBlock, void *fsdGlobalPtr, short fsid);
  549.  
  550. #if GENERATINGCFM
  551. typedef UniversalProcPtr HFSCIUPP;
  552. #else
  553. typedef HFSCIProcPtr HFSCIUPP;
  554. #endif
  555.  
  556. enum {
  557.     uppHFSCIProcInfo = kPascalStackBased
  558.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  559.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(VCBPtr)))
  560.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short)))
  561.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  562.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void *)))
  563.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(short)))
  564. };
  565.  
  566. #if GENERATINGCFM
  567. #define NewHFSCIProc(userRoutine)        \
  568.         (HFSCIUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppHFSCIProcInfo, GetCurrentArchitecture())
  569. #else
  570. #define NewHFSCIProc(userRoutine)        \
  571.         ((HFSCIUPP) (userRoutine))
  572. #endif
  573.  
  574. #if GENERATINGCFM
  575. #define CallHFSCIProc(userRoutine, theVCB, selectCode, paramBlock, fsdGlobalPtr, fsid)        \
  576.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppHFSCIProcInfo, (theVCB), (selectCode), (paramBlock), (fsdGlobalPtr), (fsid))
  577. #else
  578. #define CallHFSCIProc(userRoutine, theVCB, selectCode, paramBlock, fsdGlobalPtr, fsid)        \
  579.         (*(userRoutine))((theVCB), (selectCode), (paramBlock), (fsdGlobalPtr), (fsid))
  580. #endif
  581. struct HFSCIRec {
  582.     long                             compInterfMask;                /* component flags */
  583.     HFSCIProcPtr                     compInterfProc;                /* pointer to file system call processing code */
  584.     Lg2PhysProcPtr                     log2PhyProc;                /* pointer to Lg2PhysProc() code */
  585.     Ptr                             stackTop;                    /* file system stack top */
  586.     long                             stackSize;                    /* file system stack size */
  587.     Ptr                             stackPtr;                    /* current file system stack pointer */
  588.     long                             reserved3;                    /* --reserved, must be zero-- */
  589.     long                             idSector;                    /* Sector you need to ID a local volume. For networked volumes, this must be -1 */
  590.     long                             reserved2;                    /* --reserved, must be zero-- */
  591.     long                             reserved1;                    /* --reserved, must be zero-- */
  592. };
  593. typedef struct HFSCIRec HFSCIRec;
  594.  
  595. typedef HFSCIRec *HFSCIRecPtr;
  596. /*
  597.  *    Disk Initialization Component Interface records
  598. */
  599. typedef pascal OSErr (*DICIProcPtr)(short whatFunction, void *paramBlock, void *fsdGlobalPtr);
  600.  
  601. #if GENERATINGCFM
  602. typedef UniversalProcPtr DICIUPP;
  603. #else
  604. typedef DICIProcPtr DICIUPP;
  605. #endif
  606.  
  607. enum {
  608.     uppDICIProcInfo = kPascalStackBased
  609.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  610.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  611.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  612.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  613. };
  614.  
  615. #if GENERATINGCFM
  616. #define NewDICIProc(userRoutine)        \
  617.         (DICIUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDICIProcInfo, GetCurrentArchitecture())
  618. #else
  619. #define NewDICIProc(userRoutine)        \
  620.         ((DICIUPP) (userRoutine))
  621. #endif
  622.  
  623. #if GENERATINGCFM
  624. #define CallDICIProc(userRoutine, whatFunction, paramBlock, fsdGlobalPtr)        \
  625.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDICIProcInfo, (whatFunction), (paramBlock), (fsdGlobalPtr))
  626. #else
  627. #define CallDICIProc(userRoutine, whatFunction, paramBlock, fsdGlobalPtr)        \
  628.         (*(userRoutine))((whatFunction), (paramBlock), (fsdGlobalPtr))
  629. #endif
  630. struct DICIRec {
  631.     long                             compInterfMask;                /* component flags */
  632.     DICIProcPtr                     compInterfProc;                /* pointer to call processing code */
  633.     short                             maxVolNameLength;            /* maximum length of your volume name */
  634.     unsigned short                     blockSize;                    /* your file system's block size */
  635.     long                             reserved3;                    /* --reserved, must be zero-- */
  636.     long                             reserved2;                    /* --reserved, must be zero-- */
  637.     long                             reserved1;                    /* --reserved, must be zero-- */
  638. };
  639. typedef struct DICIRec DICIRec;
  640.  
  641. typedef DICIRec *DICIRecPtr;
  642. /*
  643.  * FormatListRec as returned by the .Sony disk driver's
  644.  * Return Format List status call (csCode = 6).
  645.  * If the status call to get this list for a drive is not
  646.  * implemented by the driver, then a list with one entry
  647.  * is contructed from the drive queue element for the drive.
  648. */
  649. struct FormatListRec {
  650.     unsigned long                     volSize;                    /* disk capacity in SECTORs */
  651.     SignedByte                         formatFlags;                /* flags */
  652.     SignedByte                         sectorsPerTrack;            /* sectors per track side */
  653.     unsigned short                     tracks;                        /* number of tracks */
  654. };
  655. typedef struct FormatListRec FormatListRec;
  656.  
  657. typedef FormatListRec *FormatListRecPtr;
  658. /*
  659.  * SizeListRec built from FormatListRecs as described above.
  660. */
  661. struct SizeListRec {
  662.     short                             sizeListFlags;                /* flags as set by external file system */
  663.     FormatListRec                     sizeEntry;                    /* disk driver format list record */
  664. };
  665. typedef struct SizeListRec SizeListRec;
  666.  
  667. typedef SizeListRec *SizeListRecPtr;
  668. /*
  669.  * paramBlock for the diCIEvaluateSize call
  670. */
  671. struct DICIEvaluateSizeRec {
  672.     short                             defaultSizeIndex;            /* default size for this FS */
  673.     short                             numSizeEntries;                /* number of size entries */
  674.     short                             driveNumber;                /* drive number */
  675.     SizeListRecPtr                     sizeListPtr;                /* ptr to size entry table */
  676.     unsigned short                     sectorSize;                    /* bytes per sector */
  677. };
  678. typedef struct DICIEvaluateSizeRec DICIEvaluateSizeRec;
  679.  
  680. typedef DICIEvaluateSizeRec *DICIEvaluateSizeRecPtr;
  681. /*
  682.  * paramBlock for the diCIExtendedZero call
  683. */
  684. struct DICIExtendedZeroRec {
  685.     short                             driveNumber;                /* drive number */
  686.     StringPtr                         volNamePtr;                    /* ptr to volume name string */
  687.     short                             fsid;                        /* file system ID */
  688.     short                             volTypeSelector;            /* volume type selector, if supports more than 1 type */
  689.     unsigned short                     numDefectBlocks;            /* number of bad logical blocks */
  690.     unsigned short                     defectListSize;                /* size of the defect list buffer in bytes */
  691.     Ptr                             defectListPtr;                /* pointer to defect list buffer */
  692.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  693.     unsigned short                     sectorSize;                    /* bytes per sector */
  694.     Ptr                             extendedInfoPtr;            /* ptr to extended info */
  695. };
  696. typedef struct DICIExtendedZeroRec DICIExtendedZeroRec;
  697.  
  698. typedef DICIExtendedZeroRec *DICIExtendedZeroRecPtr;
  699. /*
  700.  * paramBlock for the diCIValidateVolName call
  701. */
  702. struct DICIValidateVolNameRec {
  703.     char                             theChar;                    /* the character to validate */
  704.     Boolean                         hasMessageBuffer;            /* false if no message */
  705.     short                             charOffset;                    /* position of the current character (first char = 1) */
  706.     StringPtr                         messageBufferPtr;            /* pointer to message buffer or nil */
  707.     short                             charByteType;                /* theChar's byte type (smSingleByte, smFirstByte, or smLastByte) */
  708. };
  709. typedef struct DICIValidateVolNameRec DICIValidateVolNameRec;
  710.  
  711. typedef DICIValidateVolNameRec *DICIValidateVolNameRecPtr;
  712. /*
  713.  * paramBlock for the diCIGetVolTypeInfo call
  714. */
  715. struct DICIGetVolTypeInfoRec {
  716.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  717.     unsigned short                     sectorSize;                    /* bytes per sector */
  718.     short                             numVolTypes;                /* number of volume types supported */
  719.     Str31                             volTypesBuffer[4];            /* 4 string buffers */
  720. };
  721. typedef struct DICIGetVolTypeInfoRec DICIGetVolTypeInfoRec;
  722.  
  723. typedef DICIGetVolTypeInfoRec *DICIGetVolTypeInfoRecPtr;
  724. /*
  725.  * paramBlock for the diCIGetFormatString call
  726. */
  727. struct DICIGetFormatStringRec {
  728.     unsigned long                     volSize;                    /* volume size in SECTORs */
  729.     unsigned short                     sectorSize;                    /* sector size */
  730.     short                             volTypeSelector;            /* volume type selector */
  731.     short                             stringKind;                    /* sub-function = type of string */
  732.     Str255                             stringBuffer;                /* string buffer */
  733. };
  734. typedef struct DICIGetFormatStringRec DICIGetFormatStringRec;
  735.  
  736. typedef DICIGetFormatStringRec *DICIGetFormatStringRecPtr;
  737. /*
  738.  * paramBlock for the diCIGetExtendedFormatParams call
  739. */
  740. struct DICIGetExtendedFormatRec {
  741.     short                             driveNumber;                /* drive number */
  742.     short                             volTypeSelector;            /* volume type selector or 0 */
  743.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  744.     unsigned short                     sectorSize;                    /* bytes per sector */
  745.     FSSpecPtr                         fileSystemSpecPtr;            /* pointer to the foreign file system's FSSpec */
  746.     Ptr                             extendedInfoPtr;            /* pointer to extended parameter structure */
  747. };
  748. typedef struct DICIGetExtendedFormatRec DICIGetExtendedFormatRec;
  749.  
  750. typedef DICIGetExtendedFormatRec *DICIGetExtendedFormatRecPtr;
  751. /*
  752.  *    File System Manager records
  753. */
  754. typedef pascal OSErr (*FSDCommProcPtr)(short message, void *paramBlock, void *globalsPtr);
  755.  
  756. #if GENERATINGCFM
  757. typedef UniversalProcPtr FSDCommUPP;
  758. #else
  759. typedef FSDCommProcPtr FSDCommUPP;
  760. #endif
  761.  
  762. enum {
  763.     uppFSDCommProcInfo = kPascalStackBased
  764.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  765.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  766.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  767.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  768. };
  769.  
  770. #if GENERATINGCFM
  771. #define NewFSDCommProc(userRoutine)        \
  772.         (FSDCommUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppFSDCommProcInfo, GetCurrentArchitecture())
  773. #else
  774. #define NewFSDCommProc(userRoutine)        \
  775.         ((FSDCommUPP) (userRoutine))
  776. #endif
  777.  
  778. #if GENERATINGCFM
  779. #define CallFSDCommProc(userRoutine, message, paramBlock, globalsPtr)        \
  780.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppFSDCommProcInfo, (message), (paramBlock), (globalsPtr))
  781. #else
  782. #define CallFSDCommProc(userRoutine, message, paramBlock, globalsPtr)        \
  783.         (*(userRoutine))((message), (paramBlock), (globalsPtr))
  784. #endif
  785. typedef struct FSDRec FSDRec;
  786. struct FSDRec {
  787.     struct FSDRec *                    fsdLink;                    /* ptr to next */
  788.     short                             fsdLength;                    /* length of this FSD in BYTES */
  789.     short                             fsdVersion;                    /* version number */
  790.     short                             fileSystemFSID;                /* file system id */
  791.     Str31                             fileSystemName;                /* file system name */
  792.     FSSpec                             fileSystemSpec;                /* foreign file system's FSSpec */
  793.     Ptr                             fileSystemGlobalsPtr;        /* ptr to file system globals */
  794.     FSDCommProcPtr                     fileSystemCommProc;            /* communication proc with the FFS */
  795.     long                             reserved3;                    /* --reserved, must be zero-- */
  796.     long                             reserved2;                    /* --reserved, must be zero-- */
  797.     long                             reserved1;                    /* --reserved, must be zero-- */
  798.     HFSCIRec                         fsdHFSCI;                    /* HFS component interface    */
  799.     DICIRec                         fsdDICI;                    /* Disk Initialization component interface */
  800. };
  801.  
  802. typedef FSDRec *FSDRecPtr;
  803. struct FSMGetIconInfoRec {
  804.     long                             theIcon[32];                /* The ICN# structure */
  805.     long                             theMask[32];                /* The mask for the icon above */
  806.     Str255                             whereStr;
  807. };
  808. typedef struct FSMGetIconInfoRec FSMGetIconInfoRec;
  809.  
  810. typedef FSMGetIconInfoRec *FSMGetIconInfoRecPtr;
  811. /*
  812.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  813. */
  814. struct FSMGetIconRec {
  815.     short                             refNum;                        /* target drive num or volume refnum */
  816.     FSMGetIconInfoRecPtr             iconBufferPtr;                /* pointer to icon buffer */
  817.     long                             requestSize;                /* requested size of the icon buffer */
  818.     long                             actualSize;                    /* actual size of the icon data returned */
  819.     SInt8                             iconType;                    /* kind of icon */
  820.     Boolean                         isEjectable;                /* true if the device is ejectable */
  821.     DrvQElPtr                         driveQElemPtr;                /* pointer to DQE */
  822.     FSSpecPtr                         fileSystemSpecPtr;            /* pointer to foreign file system's FSSpec */
  823.     long                             reserved1;                    /* --reserved, must be zero-- */
  824. };
  825. typedef struct FSMGetIconRec FSMGetIconRec;
  826.  
  827. typedef FSMGetIconRec *FSMGetIconRecPtr;
  828. /*
  829.  *    HFS Utility routine prototypes
  830. */
  831. extern pascal OSErr UTAllocateFCB(short *fileRefNum, FCBRecPtr *fileCtrlBlockPtr)
  832.  TWOWORDINLINE(0x7000, 0xA824);
  833.  
  834. extern pascal OSErr UTReleaseFCB(short fileRefNum)
  835.  TWOWORDINLINE(0x7001, 0xA824);
  836.  
  837. extern pascal OSErr UTLocateFCB(VCBPtr volCtrlBlockPtr, unsigned long fileNum, StringPtr namePtr, short *fileRefNum, FCBRecPtr *fileCtrlBlockPtr)
  838.  TWOWORDINLINE(0x7002, 0xA824);
  839.  
  840. extern pascal OSErr UTLocateNextFCB(VCBPtr volCtrlBlockPtr, unsigned long fileNum, StringPtr namePtr, short *fileRefNum, FCBRecPtr *fileCtrlBlockPtr)
  841.  TWOWORDINLINE(0x7003, 0xA824);
  842.  
  843. extern pascal OSErr UTIndexFCB(VCBPtr volCtrlBlockPtr, short *fileRefNum, FCBRecPtr *fileCtrlBlockPtr)
  844.  TWOWORDINLINE(0x7004, 0xA824);
  845.  
  846. extern pascal OSErr UTResolveFCB(short fileRefNum, FCBRecPtr *fileCtrlBlockPtr)
  847.  TWOWORDINLINE(0x7005, 0xA824);
  848.  
  849. extern pascal OSErr UTAllocateVCB(unsigned short *sysVCBLength, VCBPtr *volCtrlBlockPtr, unsigned short addSize)
  850.  TWOWORDINLINE(0x7006, 0xA824);
  851.  
  852. extern pascal OSErr UTAddNewVCB(short driveNum, short *vRefNum, VCBPtr volCtrlBlockPtr)
  853.  TWOWORDINLINE(0x7007, 0xA824);
  854.  
  855. extern pascal OSErr UTDisposeVCB(VCBPtr volCtrlBlockPtr)
  856.  TWOWORDINLINE(0x7008, 0xA824);
  857.  
  858. extern pascal OSErr UTLocateVCBByRefNum(short refNum, short *vRefNum, VCBPtr *volCtrlBlockPtr)
  859.  TWOWORDINLINE(0x7009, 0xA824);
  860.  
  861. extern pascal OSErr UTLocateVCBByName(StringPtr namePtr, short *moreMatches, short *vRefNum, VCBPtr *volCtrlBlockPtr)
  862.  TWOWORDINLINE(0x700A, 0xA824);
  863.  
  864. extern pascal OSErr UTLocateNextVCB(StringPtr namePtr, short *moreMatches, short *vRefNum, VCBPtr *volCtrlBlockPtr)
  865.  TWOWORDINLINE(0x700B, 0xA824);
  866.  
  867. extern pascal OSErr UTAllocateWDCB(WDPBPtr paramBlock)
  868.  TWOWORDINLINE(0x700C, 0xA824);
  869.  
  870. extern pascal OSErr UTReleaseWDCB(short wdRefNum)
  871.  TWOWORDINLINE(0x700D, 0xA824);
  872.  
  873. extern pascal OSErr UTResolveWDCB(long procID, short wdIndex, short wdRefNum, WDCBRecPtr *wdCtrlBlockPtr)
  874.  TWOWORDINLINE(0x700E, 0xA824);
  875.  
  876. extern pascal OSErr UTFindDrive(short driveNum, DrvQElPtr *driveQElementPtr)
  877.  TWOWORDINLINE(0x700F, 0xA824);
  878.  
  879. extern pascal OSErr UTAdjustEOF(short fileRefNum)
  880.  TWOWORDINLINE(0x7010, 0xA824);
  881.  
  882. extern pascal OSErr UTSetDefaultVol(long nodeHint, unsigned long dirID, short refNum)
  883.  TWOWORDINLINE(0x7011, 0xA824);
  884.  
  885. extern pascal OSErr UTGetDefaultVol(WDPBPtr paramBlock)
  886.  TWOWORDINLINE(0x7012, 0xA824);
  887.  
  888. extern pascal OSErr UTEjectVol(VCBPtr volCtrlBlockPtr)
  889.  TWOWORDINLINE(0x702B, 0xA824);
  890.  
  891. extern pascal OSErr UTCheckWDRefNum(short wdRefNum)
  892.  TWOWORDINLINE(0x7013, 0xA824);
  893.  
  894. extern pascal OSErr UTCheckFileRefNum(short fileRefNum)
  895.  TWOWORDINLINE(0x7014, 0xA824);
  896.  
  897. extern pascal OSErr UTCheckVolRefNum(short vRefNum)
  898.  TWOWORDINLINE(0x7015, 0xA824);
  899.  
  900. extern pascal OSErr UTCheckPermission(VCBPtr volCtrlBlockPtr, short *modByte, unsigned long fileNum, ParmBlkPtr paramBlock)
  901.  TWOWORDINLINE(0x7016, 0xA824);
  902.  
  903. extern pascal OSErr UTCheckVolOffline(short vRefNum)
  904.  TWOWORDINLINE(0x7017, 0xA824);
  905.  
  906. extern pascal OSErr UTCheckVolModifiable(short vRefNum)
  907.  TWOWORDINLINE(0x7018, 0xA824);
  908.  
  909. extern pascal OSErr UTCheckFileModifiable(short fileRefNum)
  910.  TWOWORDINLINE(0x7019, 0xA824);
  911.  
  912. extern pascal OSErr UTCheckDirBusy(VCBPtr volCtrlBlockPtr, unsigned long dirID)
  913.  TWOWORDINLINE(0x701A, 0xA824);
  914.  
  915. extern pascal OSErr UTParsePathname(short *volNamelength, StringPtr namePtr)
  916.  TWOWORDINLINE(0x701B, 0xA824);
  917.  
  918. extern pascal OSErr UTGetPathComponentName(ParsePathRecPtr parseRec)
  919.  TWOWORDINLINE(0x701C, 0xA824);
  920.  
  921. extern pascal OSErr UTDetermineVol(ParmBlkPtr paramBlock, short *status, short *moreMatches, short *vRefNum, VCBPtr *volCtrlBlockPtr)
  922.  TWOWORDINLINE(0x701D, 0xA824);
  923.  
  924. extern pascal OSErr UTGetBlock(short refNum, void *log2PhyProc, unsigned long blockNum, short gbOption, Ptr *buffer)
  925.  TWOWORDINLINE(0x701F, 0xA824);
  926.  
  927. extern pascal OSErr UTReleaseBlock(Ptr buffer, short rbOption)
  928.  TWOWORDINLINE(0x7020, 0xA824);
  929.  
  930. extern pascal OSErr UTFlushCache(short refNum, short fcOption)
  931.  TWOWORDINLINE(0x7021, 0xA824);
  932.  
  933. extern pascal OSErr UTMarkDirty(Ptr buffer)
  934.  TWOWORDINLINE(0x7023, 0xA824);
  935.  
  936. extern pascal OSErr UTTrashVolBlocks(VCBPtr volCtrlBlockPtr)
  937.  TWOWORDINLINE(0x7024, 0xA824);
  938.  
  939. extern pascal OSErr UTTrashFileBlocks(VCBPtr volCtrlBlockPtr, unsigned long fileNum)
  940.  TWOWORDINLINE(0x7025, 0xA824);
  941.  
  942. extern pascal OSErr UTTrashBlocks(unsigned long beginPosition, unsigned long byteCount, VCBPtr volCtrlBlockPtr, short fileRefNum, short tbOption)
  943.  TWOWORDINLINE(0x7026, 0xA824);
  944.  
  945. extern pascal OSErr UTCacheReadIP(void *log2PhyProc, unsigned long filePosition, Ptr ioBuffer, short fileRefNum, unsigned long reqCount, unsigned long *actCount, short cacheOption)
  946.  TWOWORDINLINE(0x7027, 0xA824);
  947.  
  948. extern pascal OSErr UTCacheWriteIP(void *log2PhyProc, unsigned long filePosition, Ptr ioBuffer, short fileRefNum, unsigned long reqCount, unsigned long *actCount, short cacheOption)
  949.  TWOWORDINLINE(0x7028, 0xA824);
  950.  
  951. extern pascal OSErr UTBlockInFQHashP(short vRefNum, unsigned long diskBlock)
  952.  TWOWORDINLINE(0x702C, 0xA824);
  953.  
  954. /*
  955.  *    File System Manager call prototypes
  956. */
  957. extern pascal OSErr InstallFS(FSDRecPtr fsdPtr);
  958.  
  959. extern pascal OSErr RemoveFS(short fsid);
  960.  
  961. extern pascal OSErr SetFSInfo(short fsid, short bufSize, FSDRecPtr fsdPtr);
  962.  
  963. extern pascal OSErr GetFSInfo(short selector, short key, short *bufSize, FSDRecPtr fsdPtr);
  964.  
  965. extern pascal OSErr InformFSM(short theMessage, void *paramBlock);
  966.  
  967. extern pascal OSErr InformFFS(short fsid, void *paramBlock);
  968.  
  969. #endif
  970.  
  971. #if PRAGMA_ALIGN_SUPPORTED
  972. #pragma options align=reset
  973. #endif
  974.  
  975. #if PRAGMA_IMPORT_SUPPORTED
  976. #pragma import off
  977. #endif
  978.  
  979. #ifdef __cplusplus
  980. }
  981. #endif
  982.  
  983. #endif /* __FSM__ */
  984.  
  985.